{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Inception块\n",
    "\n",
    "可以利用Inception块构建经典网络InceptionNet，也就是GoolgeNet\n",
    "\n",
    "那么，以CIFAR-10 数据集的分类为例，采用GoolgeNet模型来解决问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 数据读取\n",
    "\n",
    "CIFAR-10 数据集的分类是机器学习中一个公开的基准测试问题\n",
    "\n",
    "其任务是对一组32x32RGB的图像进行分类，这些图像涵盖了10个类别：\n",
    "飞机， 汽车， 鸟， 猫， 鹿， 狗， 青蛙， 马， 船以及卡车\n",
    "\n",
    "利用网上的 CIFAR-10 数据集 获取数据集压缩文件，这里使用的是python版本 CIFAR-10 python version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data file already exists.\n",
      "Directory already exists.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import urllib.request\n",
    "import tarfile\n",
    "import pickle as p\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "# 下载 cifar10\n",
    "url = 'https://www.cs.toronto.edu/-kriz/cifar-10-python.tar.gz'\n",
    "filepath = '../data/cifar-10-python.tar.gz'\n",
    "if not os.path.isfile(filepath):\n",
    "    result = urllib.request.urlretrieve(url, filepath)\n",
    "    print('downloaded', result)\n",
    "else:\n",
    "    print('Data file already exists.')\n",
    "\n",
    "# 解压 cifar10\n",
    "if not os.path.exists(\"../data/cifar-10-batches-py\"):\n",
    "    tfile = tarfile.open(\"../data/cifar-10-python.tar.gz\", 'r:gz')\n",
    "    result = tfile.extractall(\"../data/\")\n",
    "    print('Extracted to ./../data/cifar-10-batches-py/')\n",
    "else:\n",
    "    print('Directory already exists.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加载数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading ../data/cifar-10-batches-py/data_batch_1\n",
      "loading ../data/cifar-10-batches-py/data_batch_2\n",
      "loading ../data/cifar-10-batches-py/data_batch_3\n",
      "loading ../data/cifar-10-batches-py/data_batch_4\n",
      "loading ../data/cifar-10-batches-py/data_batch_5\n",
      "finished loadding CIFAR-10 data\n"
     ]
    }
   ],
   "source": [
    "def load_CIFAR_batch(filename):\n",
    "    \"\"\"oad single batch of cifar\"\"\"\n",
    "    with open(filename, 'rb')as f:\n",
    "        # 一个样本由标签和图像数据组成\n",
    "        # <1 xlabel><3072 xpixel> (3072-32x32x3)\n",
    "        data_dict = p.load(f, encoding='bytes')\n",
    "        images = data_dict[b'data']\n",
    "        labels = data_dict[b'labels']\n",
    "        # 把原始数据结构调整为: BCWH\n",
    "        images = images.reshape(10000, 3, 32, 32)\n",
    "        # tensorflow处理图像数据的结构: BWHC\n",
    "        # #把通道数据C移动到最后一个维度\n",
    "        images = images.transpose(0, 2, 3, 1)\n",
    "        labels = np.array(labels)\n",
    "        return images, labels\n",
    "\n",
    "\n",
    "def load_CIFAR_data(data_dir):\n",
    "    \"\"\"load CIFAR data\"\"\"\n",
    "    images_train = []\n",
    "    labels_train = []\n",
    "    for i in range(5):\n",
    "        f = os.path.join(data_dir, 'data_batch_{0}'.format(i + 1))\n",
    "        print('loading', f)\n",
    "        # 调用loadCIFARbatch(获得批量的图像及其对应的标签\n",
    "        image_batch, label_batch = load_CIFAR_batch(f)\n",
    "        images_train.append(image_batch)\n",
    "        labels_train.append(label_batch)\n",
    "        Xtrain = np.concatenate(images_train)\n",
    "        Ytrain = np.concatenate(labels_train)\n",
    "        del image_batch, label_batch\n",
    "    Xtest, Ytest = load_CIFAR_batch(os.path.join(data_dir, 'test_batch'))\n",
    "    print('finished loadding CIFAR-10 data')\n",
    "    # 返回训练集的图象和标签，测试集的图像和标签\n",
    "    return Xtrain, Ytrain, Xtest, Ytest\n",
    "\n",
    "\n",
    "data_dir = '../data/cifar-10-batches-py/'\n",
    "Xtrain, Ytrain, Xtest, Ytest = load_CIFAR_data(data_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看数据集数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training data shape: (50000, 32, 32, 3)\n",
      "training labels shape: (50000,)\n",
      "test data shape: (10000, 32, 32, 3)\n",
      "test labels shape: (10000,)\n"
     ]
    }
   ],
   "source": [
    "print('training data shape:', Xtrain.shape)\n",
    "print('training labels shape:', Ytrain.shape)\n",
    "print('test data shape:', Xtest.shape)\n",
    "print('test labels shape:', Ytest.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义标签字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_dict = {0: \"airplane\", 1: \"automobile\", 2: \"bird\", 3: \"cat\", 4: \"deer\",\n",
    "              5: \"dog\", 6: \"frog\", 7: \"horse\", 8: \"ship\", 9: \"truck\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看第11张图片并查看对应的label，虽然模模糊糊，但还可以猜出来是十个类别中的鹿"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Xtrain[10] label: deer\n"
     ]
    }
   ],
   "source": [
    "imshow_num = 10\n",
    "plt.imshow(Xtrain[imshow_num])\n",
    "plt.show()\n",
    "print(\"Xtrain[{0}] label:\".format(imshow_num), label_dict[Ytrain[imshow_num]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "图片进行数字标准化并对比数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Xtrain[0][0][0] data: [59 62 63]\n",
      "Xtrain_norm[0][0][0] data: [-1.0526042 -0.9816644 -0.7625441]\n"
     ]
    }
   ],
   "source": [
    "Xtrain_mean0 = np.mean(Xtrain.astype('float32')[:, :, :, 0])\n",
    "Xtrain_mean1 = np.mean(Xtrain.astype('float32')[:, :, :, 1])\n",
    "Xtrain_mean2 = np.mean(Xtrain.astype('float32')[:, :, :, 2])\n",
    "Xtrain_mean = [Xtrain_mean0, Xtrain_mean1, Xtrain_mean2]\n",
    "\n",
    "Xtrain_std0 = np.std(Xtrain.astype('float32')[:, :, :, 0])\n",
    "Xtrain_std1 = np.std(Xtrain.astype('float32')[:, :, :, 1])\n",
    "Xtrain_std2 = np.std(Xtrain.astype('float32')[:, :, :, 2])\n",
    "Xtrain_std = [Xtrain_std0, Xtrain_std1, Xtrain_std2]\n",
    "\n",
    "\n",
    "def data_norm(x, x_mean, x_std):\n",
    "    x_norm = x.astype('float32')\n",
    "    x_norm[:, :, :, 0] = (x_norm[:, :, :, 0] - x_mean[0]) / x_std[0]\n",
    "    x_norm[:, :, :, 1] = (x_norm[:, :, :, 1] - x_mean[1]) / x_std[1]\n",
    "    x_norm[:, :, :, 2] = (x_norm[:, :, :, 2] - x_mean[2]) / x_std[2]\n",
    "    return x_norm\n",
    "\n",
    "\n",
    "Xtrain_norm = data_norm(Xtrain, Xtrain_mean, Xtrain_std)\n",
    "Xtest_norm = data_norm(Xtest, Xtrain_mean, Xtrain_std)\n",
    "\n",
    "# 对比图像数据\n",
    "print(\"Xtrain[0][0][0] data:\", Xtrain[0][0][0])\n",
    "print(\"Xtrain_norm[0][0][0] data:\", Xtrain_norm[0][0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "标签数据处理并对比数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ytrain[10] data: 4\n",
      "Ytrain_onehot[10] data: [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "encoder = OneHotEncoder(sparse=False, categories='auto')\n",
    "yy = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]]\n",
    "encoder.fit(yy)\n",
    "Ytrain_reshape = Ytrain.reshape(-1, 1)\n",
    "Ytrain_onehot = encoder.transform(Ytrain_reshape)\n",
    "Ytest_reshape = Ytest.reshape(-1, 1)\n",
    "Ytest_onehot = encoder.transform(Ytest_reshape)\n",
    "\n",
    "print(\"Ytrain[10] data:\", Ytrain[10])\n",
    "print(\"Ytrain_onehot[10] data:\", Ytrain_onehot[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.构建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义训练数据的占位符， x是32*32*3个像素点的特征值， y是10分类的标签值\n",
    "x = tf.placeholder(tf.float32, [None, 32, 32, 3], name=\"X\")\n",
    "y = tf.placeholder(tf.float32, [None, 10], name=\"Y\")\n",
    "\n",
    "# 为了使用卷积层，需把x变成一个4d向量，其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数\n",
    "x_image = tf.reshape(x, [-1, 32, 32, 3])\n",
    "\n",
    "\n",
    "# 权重W 初始化 从标准差0.1的截断正态分布中输出随机值\n",
    "def weight_variable(shape):\n",
    "    initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "\n",
    "# 权重b 初始化 0.1\n",
    "def bias_variable(shape):\n",
    "    initial = tf.constant(0.1, shape=shape)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "\n",
    "# 定义1步长的 same卷积\n",
    "def conv2d(x, W):\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "\n",
    "# 定义1步长的 valid卷积\n",
    "def conv2d_v(x, W):\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='VALID')\n",
    "\n",
    "\n",
    "# 定义2步长的 same卷积\n",
    "def conv2d_2(x, W):\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 2, 2, 1], padding='SAME')\n",
    "\n",
    "\n",
    "# 定义步长为1 大小3x3的 max pooling\n",
    "def max_pool_3x3(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "\n",
    "# 定义步长为2 大小3x3的 max pooling\n",
    "def max_pool_3x3_2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "\n",
    "\n",
    "# 定义步长为3 大小5x5的 avg pooling\n",
    "def avg_pool_5x5(x):\n",
    "    return tf.nn.avg_pool(x, ksize=[1, 5, 5, 1], strides=[1, 3, 3, 1], padding='VALID')\n",
    "\n",
    "\n",
    "# 定义步长为1 大小7x7的 avg pooling\n",
    "def avg_pool_7x7(x):\n",
    "    return tf.nn.avg_pool(x, ksize=[1, 7, 7, 1], strides=[1, 1, 1, 1], padding='VALID')\n",
    "\n",
    "\n",
    "def inception(x, channel_in, filters_num):\n",
    "    # 第一分支 conv 1x1+1s\n",
    "    with tf.variable_scope(\"branch1\"):\n",
    "        branch1_w_conv1 = weight_variable([1, 1, channel_in, filters_num[0]])\n",
    "        branch1_b_conv1 = bias_variable([filters_num[0]])\n",
    "        branch1_h_conv1 = tf.nn.relu(conv2d(x, branch1_w_conv1) + branch1_b_conv1)\n",
    "    # 第二分支 conv 1x1+1s > conv 3x3+1s\n",
    "    with tf.variable_scope(\"branch2\"):\n",
    "        branch2_w_conv1 = weight_variable([1, 1, channel_in, filters_num[1]])\n",
    "        branch2_b_conv1 = bias_variable([filters_num[1]])\n",
    "        branch2_h_conv1 = tf.nn.relu(conv2d(x, branch2_w_conv1) + branch2_b_conv1)\n",
    "        branch2_w_conv2 = weight_variable([3, 3, filters_num[1], filters_num[2]])\n",
    "        branch2_b_conv2 = bias_variable([filters_num[2]])\n",
    "        branch2_h_conv2 = tf.nn.relu(conv2d(branch2_h_conv1, branch2_w_conv2) + branch2_b_conv2)\n",
    "    # 第三分支 conv 1x1+1s > conv 5x5+1s\n",
    "    with tf.variable_scope(\"branch3\"):\n",
    "        branch3_w_conv1 = weight_variable([1, 1, channel_in, filters_num[3]])\n",
    "        branch3_b_conv1 = bias_variable([filters_num[3]])\n",
    "        branch3_h_conv1 = tf.nn.relu(conv2d(x, branch3_w_conv1) + branch3_b_conv1)\n",
    "        branch3_w_conv2 = weight_variable([5, 5, filters_num[3], filters_num[4]])\n",
    "        branch3_b_conv2 = bias_variable([filters_num[4]])\n",
    "        branch3_h_conv2 = tf.nn.relu(conv2d(branch3_h_conv1, branch3_w_conv2) + branch3_b_conv2)\n",
    "    # 第四分支 max_pool 3x3+1s > conv 1x1+1s\n",
    "    with tf.variable_scope(\"branch4\"):\n",
    "        branch4_pool1 = max_pool_3x3(x)\n",
    "        branch4_w_conv1 = weight_variable([1, 1, channel_in, filters_num[5]])\n",
    "        branch4_b_conv1 = bias_variable([filters_num[5]])\n",
    "        branch4_h_conv1 = tf.nn.relu(conv2d(branch4_pool1, branch4_w_conv1) + branch4_b_conv1)\n",
    "    # 输出叠加\n",
    "    with tf.variable_scope(\"depth_concat\"):\n",
    "        concat = tf.concat([branch1_h_conv1, branch2_h_conv2, branch3_h_conv2, branch4_h_conv1], axis=3)\n",
    "    return concat\n",
    "\n",
    "\n",
    "# 第一层 conv 7x7+2s 64 > max_pool 3x3+2s > lrn\n",
    "# w_conv1 = weight_variable([7, 7, 3, 64])\n",
    "# b_conv1 = bias_variable([64])\n",
    "# h_conv1 = tf.nn.relu(conv2d_2(x_image, w_conv1) + b_conv1)\n",
    "# h_pool1 = max_pool_3x3_2(h_conv1)\n",
    "# hh_lrn1 = tf.nn.lrn(h_pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "\n",
    "# 第二层 conv 1x1+1s 64 > conv 3x3+1s 192 > lrn > max_pool 3x3+2s\n",
    "# w_conv2 = weight_variable([1, 1, 64, 64])\n",
    "# b_conv2 = bias_variable([64])\n",
    "# h_conv2 = tf.nn.relu(conv2d(hh_lrn1, w_conv2) + b_conv2)\n",
    "# w_conv3 = weight_variable([3, 3, 64, 192])\n",
    "# b_conv3 = bias_variable([192])\n",
    "# h_conv3 = tf.nn.relu(conv2d(h_conv2, w_conv3) + b_conv3)\n",
    "# h_lrn2 = tf.nn.lrn(h_conv3, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "# h_pool2 = max_pool_3x3_2(h_lrn2)\n",
    "\n",
    "# cifar10图片尺寸较小，为配合后续的计算，调整一些原有结构压缩成28x28x192\n",
    "# 第一层\n",
    "w_conv1 = weight_variable([3, 3, 3, 64])\n",
    "b_conv1 = bias_variable([64])\n",
    "h_conv1 = tf.nn.relu(conv2d_v(x_image, w_conv1) + b_conv1)\n",
    "h_pool1 = max_pool_3x3(h_conv1)\n",
    "hh_lrn1 = tf.nn.lrn(h_pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "# 第二层\n",
    "w_conv2 = weight_variable([1, 1, 64, 64])\n",
    "b_conv2 = bias_variable([64])\n",
    "h_conv2 = tf.nn.relu(conv2d(hh_lrn1, w_conv2) + b_conv2)\n",
    "w_conv3 = weight_variable([3, 3, 64, 192])\n",
    "b_conv3 = bias_variable([192])\n",
    "h_conv3 = tf.nn.relu(conv2d_v(h_conv2, w_conv3) + b_conv3)\n",
    "h_lrn2 = tf.nn.lrn(h_conv3, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n",
    "h_pool2 = max_pool_3x3(h_lrn2)\n",
    "\n",
    "# 第三层\n",
    "# inception 3a\n",
    "filters_num_3a = [64, 96, 128, 16, 32, 32]  # 设置inception 3a的通道数\n",
    "inception_3a = inception(h_pool2, 192, filters_num_3a)\n",
    "\n",
    "# inception 3b\n",
    "filters_num_3b = [128, 128, 192, 32, 96, 64]\n",
    "inception_3b = inception(inception_3a, 256, filters_num_3b)\n",
    "\n",
    "h_pool3 = max_pool_3x3_2(inception_3b)\n",
    "\n",
    "# 第四层                                 >\n",
    "# inception 4a\n",
    "filters_num_4a = [192, 96, 208, 16, 48, 64]\n",
    "inception_4a = inception(h_pool3, 480, filters_num_4a)\n",
    "# inception 4b\n",
    "filters_num_4b = [160, 112, 224, 24, 64, 64]\n",
    "inception_4b = inception(inception_4a, 512, filters_num_4b)\n",
    "# softmax0\n",
    "h_pool4 = avg_pool_5x5(inception_4a)\n",
    "# > conv 1x1 128\n",
    "w_conv4 = weight_variable([1, 1, 512, 128])\n",
    "b_conv4 = bias_variable([128])\n",
    "h_conv4 = tf.nn.relu(conv2d(h_pool4, w_conv4) + b_conv4)\n",
    "h_flat1 = tf.reshape(h_conv4, shape=[-1, 4 * 4 * 128])  # 重新展开\n",
    "# > fc 1x1 1024\n",
    "W_fc1 = weight_variable([4 * 4 * 128, 1024])\n",
    "b_fc1 = bias_variable([1024])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_flat1, W_fc1) + b_fc1)\n",
    "# > fc 1x1 10\n",
    "dropout_rate0 = tf.placeholder(\"float\")\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, rate=dropout_rate0)\n",
    "W_fc2 = weight_variable([1024, 10])\n",
    "b_fc2 = bias_variable([10])\n",
    "h_fc2 = tf.matmul(h_fc1_drop, W_fc2) + b_fc2\n",
    "# > softmax0\n",
    "pred0 = tf.nn.softmax(h_fc2)\n",
    "# inception 4c\n",
    "filters_num_4c = [128, 128, 256, 24, 64, 64]\n",
    "inception_4c = inception(inception_4b, 512, filters_num_4c)\n",
    "# inception 4d\n",
    "filters_num_4d = [112, 144, 288, 32, 64, 64]\n",
    "inception_4d = inception(inception_4c, 512, filters_num_4d)\n",
    "# inception 4e\n",
    "filters_num_4e = [256, 160, 320, 32, 128, 128]\n",
    "inception_4e = inception(inception_4d, 528, filters_num_4e)\n",
    "h_pool5 = max_pool_3x3_2(inception_4e)\n",
    "# softmax1\n",
    "h_pool6 = avg_pool_5x5(inception_4d)\n",
    "# > conv 1x1 128\n",
    "w_conv5 = weight_variable([1, 1, 528, 128])\n",
    "b_conv5 = bias_variable([128])\n",
    "h_conv5 = tf.nn.relu(conv2d(h_pool6, w_conv5) + b_conv5)\n",
    "h_flat2 = tf.reshape(h_conv5, shape=[-1, 4 * 4 * 128])  # 重新展开\n",
    "# > fc 1x1 1024\n",
    "W_fc3 = weight_variable([4 * 4 * 128, 1024])\n",
    "b_fc3 = bias_variable([1024])\n",
    "h_fc3 = tf.nn.relu(tf.matmul(h_flat2, W_fc3) + b_fc3)\n",
    "# > fc 1x1 10\n",
    "dropout_rate1 = tf.placeholder(\"float\")\n",
    "h_fc3_drop = tf.nn.dropout(h_fc1, rate=dropout_rate1)\n",
    "W_fc4 = weight_variable([1024, 10])\n",
    "b_fc4 = bias_variable([10])\n",
    "h_fc4 = tf.matmul(h_fc3_drop, W_fc4) + b_fc4\n",
    "# > softmax1\n",
    "pred1 = tf.nn.softmax(h_fc4)\n",
    "\n",
    "# 第五层\n",
    "# inception 5a\n",
    "filters_num_5a = [256, 160, 320, 32, 128, 128]\n",
    "inception_5a = inception(h_pool5, 832, filters_num_5a)\n",
    "# inception 5b\n",
    "filters_num_5b = [384, 192, 384, 48, 128, 128]\n",
    "inception_5b = inception(inception_5a, 832, filters_num_5b)\n",
    "\n",
    "# avg_pool_7x7\n",
    "h_pool7 = avg_pool_7x7(inception_5b)\n",
    "h_flat3 = tf.reshape(h_pool7, shape=[-1, 1 * 1 * 1024])  # 重新展开\n",
    "\n",
    "# softmax2\n",
    "dropout_rate2 = tf.placeholder(\"float\")\n",
    "h_pool7_drop = tf.nn.dropout(h_flat3, rate=dropout_rate2)\n",
    "W_fc5 = weight_variable([1024, 10])\n",
    "b_fc5 = bias_variable([10])\n",
    "h_fc5 = tf.matmul(h_pool7_drop, W_fc5) + b_fc2\n",
    "pred2 = tf.nn.softmax(h_fc5)\n",
    "\n",
    "# 整合softmax\n",
    "forward = h_fc5 + h_fc4 * 0.3 + h_fc2 * 0.3\n",
    "pred = pred2 + pred1 * 0.3 + pred0 * 0.3\n",
    "\n",
    "# 定义损失函数\n",
    "with tf.name_scope(\"LossFunction\"):\n",
    "    loss_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=forward, labels=y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0809 10:16:22.000710  6140 deprecation.py:323] From C:\\Users\\DELL\\AppData\\Roaming\\Python\\Python37\\site-packages\\tensorflow\\python\\training\\saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished loading D:/save_path/GoogleNet/model-200\n",
      "Set the load save step:200\n"
     ]
    }
   ],
   "source": [
    "train_epochs = 0  # 迭代次数 20\n",
    "learning_rate = 0.0001  # 学习率\n",
    "\n",
    "# Adam优化器 设置学习率和优化目标损失最小化\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss_function)\n",
    "\n",
    "# 定义预测类别匹配情况\n",
    "correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n",
    "\n",
    "# 定义准确率，将布尔值转化成浮点数，再求平均值\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "# 每个批次的大小，每次放入的大小，每次放入 128张图片 以矩阵的方式\n",
    "batch_size = 128\n",
    "\n",
    "# 计算一共有多少个批次，数量整除大小训练出有多少批次\n",
    "n_batch = len(Ytrain_onehot) // batch_size // 10 * 10\n",
    "\n",
    "# 定义显示训练过程中验证的间隔批量次数\n",
    "display_test_num = n_batch // 10\n",
    "\n",
    "# 定义显示训练过程.的间隔批量次数\n",
    "display_train_num = display_test_num // 10\n",
    "\n",
    "# 定义保存模型\n",
    "saver = tf.train.Saver()\n",
    "save_dir = \"../save_path/GoogleNet/\"\n",
    "\n",
    "# 定义保存模型编号\n",
    "save_step = 0\n",
    "\n",
    "# 恢复保存模型\n",
    "ckpt_dir = tf.train.latest_checkpoint(save_dir)\n",
    "sess = tf.Session()  # 建立会话\n",
    "if ckpt_dir != None:\n",
    "    saver.restore(sess, ckpt_dir)\n",
    "    print(\"Finished loading\", ckpt_dir)\n",
    "    save_step = int(input(\"Set the load save step:\"))\n",
    "else:\n",
    "    # 变量初始化\n",
    "    sess.run(tf.initialize_all_variables())\n",
    "    print(\"Finished initialize\")\n",
    "\n",
    "# 定义批次训练数据的占位符\n",
    "x_batch = tf.placeholder(tf.float32, [None, 32, 32, 3], name=\"X_batch\")\n",
    "# 随机上下翻转批次图片\n",
    "Xtrain_batch_up = tf.image.random_flip_up_down(x_batch)\n",
    "# 随机左右翻转批次图片\n",
    "Xtrain_batch_lf = tf.image.random_flip_left_right(Xtrain_batch_up)\n",
    "\n",
    "\n",
    "# 对角旋转批次图片\n",
    "# Xtrain_batch_tp = tf.image.transpose_image(x_batch)\n",
    "\n",
    "\n",
    "# 定义训练集批次函数\n",
    "def get_train_batch(num, size):\n",
    "    Xtrain_batch = Xtrain_norm_shuffle[num * size:(num + 1) * size]\n",
    "    Ytrain_batch = Ytrain_onehot_shuffle[num * size:(num + 1) * size]\n",
    "    # 随机翻转数据\n",
    "    with tf.Session() as sess_batch:\n",
    "        Xtrain_batch = sess_batch.run(Xtrain_batch_lf, feed_dict={x_batch: Xtrain_batch})\n",
    "        return Xtrain_batch, Ytrain_batch\n",
    "\n",
    "\n",
    "# 迭代训练\n",
    "for epoch in range(train_epochs):\n",
    "    # 打乱训练数据集\n",
    "    index = [i for i in range(len(Ytrain_onehot))]\n",
    "    random.shuffle(index)\n",
    "    Xtrain_norm_shuffle = Xtrain_norm[index]\n",
    "    Ytrain_onehot_shuffle = Ytrain_onehot[index]\n",
    "\n",
    "    # 批次迭代训练\n",
    "    for batch in range(0, n_batch):\n",
    "        xs, ys = get_train_batch(batch, batch_size)\n",
    "        sess.run(optimizer, feed_dict={x: xs, y: ys, dropout_rate0: 0.4, dropout_rate1: 0.4, dropout_rate2: 0.4})\n",
    "\n",
    "        if (batch + 1) % display_train_num == 0:\n",
    "            print(\".\", end=\"\")\n",
    "\n",
    "        if (batch + 1) % display_test_num == 0:\n",
    "            # 保存模型\n",
    "            save_step += 1\n",
    "            save_path = saver.save(sess, save_dir + \"model\", global_step=save_step)\n",
    "            print(\"Complete save \", save_path)\n",
    "            # 批次训练完成之后，使用验证数据计算误差与准确率\n",
    "            loss, acc = sess.run([loss_function, accuracy], feed_dict={x: xs,\n",
    "                                                                       y: ys,\n",
    "                                                                       dropout_rate0: 0,\n",
    "                                                                       dropout_rate1: 0,\n",
    "                                                                       dropout_rate2: 0})\n",
    "            # 显示训练信息\n",
    "            print(\"TrainEpoch=\", '%02d' % (epoch + 1), \"TrainBatch=\", '%04d' % (batch + 1),\n",
    "                  \"Loss=\", '{:.9f}'.format(loss), \"TrainAccuracy=\", \"{:.4f}\".format(acc))\n",
    "\n",
    "    learning_rate = 0.9 * learning_rate  # 学习率衰减"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.评估模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy:0.807292\n"
     ]
    }
   ],
   "source": [
    "test_total_batch = int(len(Xtest_norm) / batch_size)\n",
    "test_acc_sum = 0.0\n",
    "for i in range(test_total_batch):\n",
    "    test_image_batch = Xtest_norm[i * batch_size:(i + 1) * batch_size]\n",
    "    test_label_batch = Ytest_onehot[i * batch_size:(i + 1) * batch_size]\n",
    "    test_batch_acc = sess.run(accuracy, feed_dict={x: test_image_batch,\n",
    "                                                   y: test_label_batch,\n",
    "                                                   dropout_rate0: 0,\n",
    "                                                   dropout_rate1: 0,\n",
    "                                                   dropout_rate2: 0})\n",
    "    test_acc_sum += test_batch_acc\n",
    "test_acc = float(test_acc_sum / test_total_batch)\n",
    "print(\"Test accuracy:{:.6f}\".format(test_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. 模型预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看预测结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 1 8 7 1 3 0 5 7 9]\n"
     ]
    }
   ],
   "source": [
    "# 转换第201-210张测试图片pred预测结果独热编码格式为数字0-9\n",
    "prediction_result = sess.run(tf.argmax(pred, 1), feed_dict={x: Xtest_norm[200:210],\n",
    "                                                            dropout_rate0: 0,\n",
    "                                                            dropout_rate1: 0,\n",
    "                                                            dropout_rate2: 0})\n",
    "\n",
    "# 查看第201-210张测试图片的预测结果\n",
    "print(prediction_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "预测结果可视化比对"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义显示图缘数据及其对应标签的函数\n",
    "def plot_images_labels_prediction(images, labels, prediction, idx, num=10):\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(12, 6)\n",
    "    if num > 10:\n",
    "        num = 10\n",
    "    for i in range(0, num):\n",
    "        ax = plt.subplot(2, 5, 1 + i)\n",
    "        ax.imshow(images[idx], cmap=\"binary\")\n",
    "        title = str(i) + ',' + label_dict[labels[idx]]\n",
    "        if len(prediction) > 0:\n",
    "            title += '=>' + label_dict[prediction[i]]\n",
    "        ax.set_title(title, fontsize=10)\n",
    "        idx += 1\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# 验证第201-210张测试图片的预测结果\n",
    "plot_images_labels_prediction(Xtest, Ytest, prediction_result, 200, 10)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
